#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
@file logging_config.py
@brief 日志配置模块
@details 提供统一的日志配置管理，支持不同级别的日志输出
@author zhang33
@date 2025-09-05
"""

import logging
import logging.handlers
import os
import json
from typing import Dict, Any
from enum import Enum

from .constants import LogLevels


class LogMode(Enum):
    """日志模式枚举"""
    DEBUG = "debug"           # 调试模式 - 输出所有日志
    INFO = "info"             # 信息模式 - 输出信息和以上级别
    WARNING = "warning"       # 警告模式 - 输出警告和以上级别
    ERROR = "error"           # 错误模式 - 只输出错误和严重错误
    PRODUCTION = "production" # 生产模式 - 只输出错误和关键信息


class LoggingConfig:
    """
    @brief 日志配置类
    @details 管理日志配置和输出
    """
    
    def __init__(self, config_file: str = "config/logging_config.json"):
        """
        @brief 初始化日志配置
        @param config_file 日志配置文件路径
        """
        self.config_file = config_file
        self.log_mode = LogMode.INFO
        self.log_to_file = True
        self.log_to_console = True
        self.max_file_size = 10 * 1024 * 1024  # 10MB
        self.backup_count = 5
        self.log_format = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
        self.date_format = "%Y-%m-%d %H:%M:%S"
        
        # 加载配置
        self.load_config()
        
        # 配置日志
        self._setup_logging()
    
    def load_config(self) -> None:
        """
        @brief 从文件加载日志配置
        """
        try:
            if os.path.exists(self.config_file):
                with open(self.config_file, 'r', encoding='utf-8') as f:
                    config_data = json.load(f)
                
                self.log_mode = LogMode(config_data.get('log_mode', 'info'))
                self.log_to_file = config_data.get('log_to_file', True)
                self.log_to_console = config_data.get('log_to_console', True)
                self.max_file_size = config_data.get('max_file_size', 10 * 1024 * 1024)
                self.backup_count = config_data.get('backup_count', 5)
                self.log_format = config_data.get('log_format', self.log_format)
                self.date_format = config_data.get('date_format', self.date_format)
                
                print(f"日志配置加载成功: {self.log_mode.value}")
            else:
                print("日志配置文件不存在，使用默认配置")
                self._create_default_config()
                
        except Exception as e:
            print(f"加载日志配置失败: {e}，使用默认配置")
    
    def save_config(self) -> bool:
        """
        @brief 保存日志配置到文件
        @return bool 保存是否成功
        """
        try:
            config_data = {
                'log_mode': self.log_mode.value,
                'log_to_file': self.log_to_file,
                'log_to_console': self.log_to_console,
                'max_file_size': self.max_file_size,
                'backup_count': self.backup_count,
                'log_format': self.log_format,
                'date_format': self.date_format
            }
            
            with open(self.config_file, 'w', encoding='utf-8') as f:
                json.dump(config_data, f, indent=4, ensure_ascii=False)
            
            print("日志配置保存成功")
            return True
            
        except Exception as e:
            print(f"保存日志配置失败: {e}")
            return False
    
    def _create_default_config(self) -> None:
        """
        @brief 创建默认配置文件
        """
        try:
            self.save_config()
        except Exception as e:
            print(f"创建默认日志配置失败: {e}")
    
    def _setup_logging(self) -> None:
        """
        @brief 设置日志系统
        """
        # 获取日志级别
        log_level = self._get_log_level()
        
        # 创建根日志记录器
        root_logger = logging.getLogger()
        root_logger.setLevel(log_level)
        
        # 清除现有的处理器
        root_logger.handlers.clear()
        
        # 创建格式化器
        formatter = logging.Formatter(self.log_format, self.date_format)
        
        # 控制台处理器
        if self.log_to_console:
            console_handler = logging.StreamHandler()
            console_handler.setLevel(log_level)
            console_handler.setFormatter(formatter)
            root_logger.addHandler(console_handler)
        
        # 文件处理器
        if self.log_to_file:
            # 确保日志目录存在
            log_dir = "logs"
            if not os.path.exists(log_dir):
                os.makedirs(log_dir)
            
            # 主日志文件
            main_log_file = os.path.join(log_dir, "motor_controller.log")
            main_handler = logging.handlers.RotatingFileHandler(
                main_log_file,
                maxBytes=self.max_file_size,
                backupCount=self.backup_count,
                encoding='utf-8'
            )
            main_handler.setLevel(log_level)
            main_handler.setFormatter(formatter)
            root_logger.addHandler(main_handler)
            
            # 错误日志文件
            error_log_file = os.path.join(log_dir, "error.log")
            error_handler = logging.handlers.RotatingFileHandler(
                error_log_file,
                maxBytes=self.max_file_size,
                backupCount=self.backup_count,
                encoding='utf-8'
            )
            error_handler.setLevel(logging.ERROR)
            error_handler.setFormatter(formatter)
            root_logger.addHandler(error_handler)
            
            # 调试日志文件（仅在调试模式下）
            if self.log_mode == LogMode.DEBUG:
                debug_log_file = os.path.join(log_dir, "debug.log")
                debug_handler = logging.handlers.RotatingFileHandler(
                    debug_log_file,
                    maxBytes=self.max_file_size,
                    backupCount=self.backup_count,
                    encoding='utf-8'
                )
                debug_handler.setLevel(logging.DEBUG)
                debug_handler.setFormatter(formatter)
                root_logger.addHandler(debug_handler)
    
    def _get_log_level(self) -> int:
        """
        @brief 根据日志模式获取日志级别
        @return int 日志级别
        """
        level_map = {
            LogMode.DEBUG: LogLevels.DEBUG,
            LogMode.INFO: LogLevels.INFO,
            LogMode.WARNING: LogLevels.WARNING,
            LogMode.ERROR: LogLevels.ERROR,
            LogMode.PRODUCTION: LogLevels.ERROR
        }
        return level_map.get(self.log_mode, LogLevels.INFO)
    
    def set_log_mode(self, mode: LogMode) -> None:
        """
        @brief 设置日志模式
        @param mode 日志模式
        """
        self.log_mode = mode
        self._setup_logging()
        print(f"日志模式已设置为: {mode.value}")
    
    def get_log_mode(self) -> LogMode:
        """
        @brief 获取当前日志模式
        @return LogMode 当前日志模式
        """
        return self.log_mode
    
    def enable_file_logging(self, enable: bool = True) -> None:
        """
        @brief 启用/禁用文件日志
        @param enable 是否启用
        """
        self.log_to_file = enable
        self._setup_logging()
        print(f"文件日志已{'启用' if enable else '禁用'}")
    
    def enable_console_logging(self, enable: bool = True) -> None:
        """
        @brief 启用/禁用控制台日志
        @param enable 是否启用
        """
        self.log_to_console = enable
        self._setup_logging()
        print(f"控制台日志已{'启用' if enable else '禁用'}")


# 全局日志配置实例
_logging_config = None


def get_logging_config() -> LoggingConfig:
    """
    @brief 获取全局日志配置实例
    @return LoggingConfig 日志配置实例
    """
    global _logging_config
    if _logging_config is None:
        _logging_config = LoggingConfig()
    return _logging_config


def setup_logging(config_file: str = "logging_config.json") -> LoggingConfig:
    """
    @brief 设置日志系统
    @param config_file 日志配置文件路径
    @return LoggingConfig 日志配置实例
    """
    global _logging_config
    _logging_config = LoggingConfig(config_file)
    return _logging_config


def get_logger(name: str) -> logging.Logger:
    """
    @brief 获取日志记录器
    @param name 日志记录器名称
    @return logging.Logger 日志记录器
    """
    return logging.getLogger(name)
